Emit `transform: ["tailcall"]` on the TCO back-edge JUMP, alongside the
invoke/return pair it already carries, so a debugger sees the pair as a
tail-call-optimized back-edge rather than a real frame push/pop and does
not invent a spurious frame.

Render it in the tracer drawer — an optimizer-level (O0-O3) selector and a
tail-call-aware call stack — and document it with a tracing example and a
walkthrough homed in the trace playground.

Introduces the shared `Ir.Utils.addTransform` helper — the fold, coalesce,
and inline emitters all route through it — and the transform-emission test
file (`transform-contexts.test.ts`, with the `countTransform` helper),
covering the tailcall marker: absent at O0/O1, present at O2/O3.

Mark constant-folded values with `transform: ["fold"]` through a shared
`addTransform` helper, so the tracer can show a value as a
compile-time-evaluated constant rather than source. The marker composes
with later passes into a multiset (e.g. `["fold", "coalesce"]`).

Mark the SHL/OR field-packing sequence produced by read-write merging
with `transform: ["coalesce"]`, so a packed-storage write reads as
compiler-synthesized rather than source the user wrote. Composes with a
folded value into `["fold", "coalesce"]`.

Correlate activations with an `activation` identifier on invoke, return,
and revert: the invoke that opens an activation and the return or revert
that closes it carry the same value, so a debugger pairs a call with its
return independent of trace order. It lives inside the
invoke/return/revert object, keeping a tail call's two facts flat without
a `gather`.

Show the tailcall and inline transform annotations inline in the tracer's
instruction list, so the optimizer passes applied to each instruction are
visible as you step through the trace.